home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update25.zoo / util / diffs
Encoding:
Text File  |  1992-10-10  |  22.4 KB  |  887 lines
  1. *** 1.32    1992/08/14 17:24:38
  2. --- Changelog    1992/10/11 02:44:26
  3. ***************
  4. *** 342,344 ****
  5. --- 342,379 ----
  6.       put out file symbols ala aln. julians nm should do better now.
  7.   
  8.   ----------------------------- Patchlevel 31 --------------------------------
  9. + 
  10. + sym-ld.c:: michal
  11. +     was`nt compiling anymore.
  12. + 
  13. + ld.c, sym-ld.c:: michal
  14. +     When searching through a library a function symdef_library was
  15. +     repeatedly allocating and freeing (at the same address)
  16. +     subentry->strings and subentry (line 2962) and later it was executing
  17. +         free (subentry->strings);
  18. +                 subentry->strings = 0;
  19. +     My NeXT was patient enough to survive such treatment for a few
  20. +     iterations but after a while it was dropping a core from malloc().
  21. +     Exactly the same applies to sym-ld. I do not know why this problem
  22. + 
  23. + ld.c :: howard
  24. +     Incorporate baserel patches.
  25. + 
  26. + toglclr.c:: Frank Ridderbusch
  27. +     rewrote toglclr for all flags: usage
  28. +         toglclr [options] file file ...
  29. + 
  30. +     options: -fload = toggle `fast load'
  31. +              -frun  = toggle `load program into fast ram'
  32. +                  -fram  = toggle `malloc from fast ram'
  33. + 
  34. + toglclr.c:: ++jrb
  35. +     clean it up for cross-environment, add support for
  36. +         WORD_ALIGNED
  37. + 
  38. + Makefile.cross, Makefile.st:: ++jrb
  39. +     add target for toglclr
  40. + 
  41. + cnm.c:: ++jrb
  42. +     cleanup for hpux
  43. + ----------------------------- Patchlevel 32 --------------------------------
  44. *** 1.13    1992/06/03 18:40:27
  45. --- Makefile.cross    1992/10/11 02:44:26
  46. ***************
  47. *** 23,29 ****
  48.   CFLAGS = -O -I. -I$(HOSTINC) -I$(CROSSINC) -DCROSSATARI=1 \
  49.   -DCROSSDIR=\"$(CROSSDIR)\" -DCROSSLIB=\"$(CROSSLIB)\" -DWORD_ALIGNED=1
  50.   
  51. ! ALL = ld sym-ld nm car size size68 tnm xstrip fixstk printstk
  52.   
  53.   all: $(ALL)
  54.   #
  55. --- 23,29 ----
  56.   CFLAGS = -O -I. -I$(HOSTINC) -I$(CROSSINC) -DCROSSATARI=1 \
  57.   -DCROSSDIR=\"$(CROSSDIR)\" -DCROSSLIB=\"$(CROSSLIB)\" -DWORD_ALIGNED=1
  58.   
  59. ! ALL = ld sym-ld nm car size size68 tnm xstrip fixstk printstk toglclr
  60.   
  61.   all: $(ALL)
  62.   #
  63. ***************
  64. *** 74,79 ****
  65. --- 74,85 ----
  66.   xstrip: strip.o
  67.       $(CC) -o xstrip strip.o
  68.   
  69. + #
  70. + # TOS format flags manipulator
  71. + #
  72. + toglclr: toglclr.o
  73. +     $(CC) -o toglclr toglclr.o
  74. + 
  75.   install: $(ALL)
  76.       cp ld $(CROSSLIB)/gcc-ld
  77.       cp nm $(CROSSBIN)/cnm
  78. ***************
  79. *** 84,89 ****
  80. --- 90,96 ----
  81.       cp xstrip $(CROSSBIN)/xstrip
  82.       cp sym-ld $(CROSSBIN)/sym-ld
  83.       cp  fixstk printstk $(CROSSBIN)
  84. +     cp  toglclr $(CROSSBIN)
  85.   
  86.   clean:
  87.       rm -f *.o
  88. *** 1.3    1992/06/03 18:40:27
  89. --- Makefile.hp    1992/10/11 02:44:26
  90. ***************
  91. *** 29,35 ****
  92.   
  93.   LIBS = $(ALLOCA) $(MALLOC1)
  94.   
  95. ! ALL = ld sym-ld nm car size size68 tnm xstrip  fixstk printstk
  96.   
  97.   all: $(ALL)
  98.   #
  99. --- 29,35 ----
  100.   
  101.   LIBS = $(ALLOCA) $(MALLOC1)
  102.   
  103. ! ALL = ld sym-ld nm car size size68 tnm xstrip  fixstk printstk toglclr
  104.   
  105.   all: $(ALL)
  106.   #
  107. ***************
  108. *** 80,85 ****
  109. --- 80,91 ----
  110.   xstrip: strip.o
  111.       $(CC) -o xstrip strip.o $(LIBS)
  112.   
  113. + #
  114. + # TOS format flags manipulator
  115. + #
  116. + toglclr: toglclr.o
  117. +     $(CC) -o toglclr toglclr.o
  118. + 
  119.   install: $(ALL)
  120.       cp ld $(CROSSLIB)/gcc-ld
  121.       cp nm $(CROSSBIN)/cnm
  122. ***************
  123. *** 89,95 ****
  124.       cp tnm $(CROSSBIN)/tnm
  125.       cp xstrip $(CROSSBIN)/xstrip
  126.       cp sym-ld $(CROSSBIN)/sym-ld
  127. !     cp  fixstk printstk $(CROSSBIN)
  128.   
  129.   clean:
  130.       rm -f *.o
  131. --- 95,101 ----
  132.       cp tnm $(CROSSBIN)/tnm
  133.       cp xstrip $(CROSSBIN)/xstrip
  134.       cp sym-ld $(CROSSBIN)/sym-ld
  135. !     cp  fixstk printstk toglclr $(CROSSBIN)
  136.   
  137.   clean:
  138.       rm -f *.o
  139. *** 1.12    1992/06/11 17:45:54
  140. --- Makefile.st    1992/10/11 02:44:26
  141. ***************
  142. *** 18,24 ****
  143.   #ALL = gcc-ld.ttp sym-ld.ttp gcc-nm.ttp gcc-ar.ttp gcc-size.ttp size68.ttp 
  144.   #      cnm.ttp fixstk.ttp printstk.ttp
  145.   ALL = gcc-ld.ttp gcc-nm.ttp gcc-ar.ttp gcc-size.ttp size68.ttp \
  146. !       cnm.ttp fixstk.ttp printstk.ttp xstrip.ttp sym-ld.ttp
  147.   all: $(ALL)
  148.   
  149.   #
  150. --- 18,24 ----
  151.   #ALL = gcc-ld.ttp sym-ld.ttp gcc-nm.ttp gcc-ar.ttp gcc-size.ttp size68.ttp 
  152.   #      cnm.ttp fixstk.ttp printstk.ttp
  153.   ALL = gcc-ld.ttp gcc-nm.ttp gcc-ar.ttp gcc-size.ttp size68.ttp \
  154. !       cnm.ttp fixstk.ttp printstk.ttp xstrip.ttp sym-ld.ttp toglclr.ttp
  155.   all: $(ALL)
  156.   
  157.   #
  158. ***************
  159. *** 81,86 ****
  160. --- 81,92 ----
  161.   #
  162.   xstrip.ttp: strip.c
  163.       $(CC) -O -o xstrip.ttp strip.c -mshort -liio16
  164. + 
  165. + #
  166. + # Manipulate TOS executable header  flags
  167. + #
  168. + toglclr.ttp: toglclr.c
  169. +     $(CC) -O -o toglclr.ttp toglclr.c -mshort -liio16
  170.   
  171.   clean:
  172.       rm -f *.o core
  173. *** 1.1    1991/08/13 21:17:30
  174. --- Makefile.st.hp    1992/10/11 02:44:26
  175. ***************
  176. *** 12,24 ****
  177.   # Cross GCC
  178.   CC=$(CROSSBIN)/cgcc
  179.   
  180. ! CFLAGS = -O -Datarist -I.
  181.   LDFLAGS = -liio
  182.   
  183.   #ALL = gcc-ld.ttp sym-ld.ttp gcc-nm.ttp gcc-ar.ttp gcc-size.ttp size68.ttp 
  184.   #      cnm.ttp fixstk.ttp printstk.ttp
  185.   ALL = gcc-ld.ttp gcc-nm.ttp gcc-ar.ttp gcc-size.ttp size68.ttp \
  186. !       cnm.ttp fixstk.ttp printstk.ttp xstrip.ttp sym-ld.ttp
  187.   all: $(ALL)
  188.   
  189.   #
  190. --- 12,24 ----
  191.   # Cross GCC
  192.   CC=$(CROSSBIN)/cgcc
  193.   
  194. ! CFLAGS = -O2 -fstrength-reduce -fomit-frame-pointer -Datarist -I.
  195.   LDFLAGS = -liio
  196.   
  197.   #ALL = gcc-ld.ttp sym-ld.ttp gcc-nm.ttp gcc-ar.ttp gcc-size.ttp size68.ttp 
  198.   #      cnm.ttp fixstk.ttp printstk.ttp
  199.   ALL = gcc-ld.ttp gcc-nm.ttp gcc-ar.ttp gcc-size.ttp size68.ttp \
  200. !       cnm.ttp fixstk.ttp printstk.ttp xstrip.ttp sym-ld.ttp toglclr.ttp
  201.   all: $(ALL)
  202.   
  203.   #
  204. ***************
  205. *** 81,86 ****
  206. --- 81,92 ----
  207.   #
  208.   xstrip.ttp: strip.c
  209.       $(CC) -O -o xstrip.ttp strip.c -mshort -liio16
  210. + 
  211. + #
  212. + # Manipulate TOS executable header  flags
  213. + #
  214. + toglclr.ttp: toglclr.c
  215. +     $(CC) -O -o toglclr.ttp toglclr.c -mshort -liio16
  216.   
  217.   clean:
  218.       rm -f *.o core
  219. *** 1.29    1992/08/14 17:24:38
  220. --- PatchLev.h    1992/10/11 02:44:27
  221. ***************
  222. *** 1,4 ****
  223. ! #define PatchLevel "31"
  224.   
  225.   /*
  226.    *    the Patch Level above is to identify the version
  227. --- 1,4 ----
  228. ! #define PatchLevel "32"
  229.   
  230.   /*
  231.    *    the Patch Level above is to identify the version
  232. *** 1.7    1992/08/14 17:24:38
  233. --- cnm.c    1992/10/11 02:44:27
  234. ***************
  235. *** 36,41 ****
  236. --- 36,47 ----
  237.   #include <stdio.h>
  238.   #include <st-out.h>
  239.   
  240. + #if __STDC__
  241. + #include <stdlib.h>
  242. + #else
  243. + extern char *malloc(), *realloc();
  244. + #endif
  245. + 
  246.   #ifdef atarist
  247.   # define READB    "rb"
  248.   #else
  249. ***************
  250. *** 42,48 ****
  251.   # define READB "r"
  252.   #endif
  253.   
  254. ! #if !__STDC__
  255.   typedef unsigned long size_t;
  256.   #endif
  257.   
  258. --- 48,54 ----
  259.   # define READB "r"
  260.   #endif
  261.   
  262. ! #if !__STDC__ && !defined(hpux)
  263.   typedef unsigned long size_t;
  264.   #endif
  265.   
  266. ***************
  267. *** 348,350 ****
  268. --- 354,380 ----
  269.       fprintf(stderr, "cnm [-g] files...\n");
  270.       exit(1);
  271.   }
  272. + 
  273. + #if !defined(__GNUC__) &&  defined(hpux)
  274. + 
  275. + char *xmalloc(n)
  276. + int n;    /* sigh! */
  277. + {
  278. +    char *ret = (char *)malloc(n);
  279. + 
  280. +    if(ret) return ret;
  281. +    perror("malloc");
  282. +    exit(1);
  283. + }
  284. + 
  285. + char *xrealloc(b, n)
  286. + char * b;
  287. + int n;    /* sigh! */
  288. + {
  289. +    char *ret = (char *)realloc(b, n);
  290. + 
  291. +    if(ret) return ret;
  292. +    perror("realloc");
  293. +    exit(2);
  294. + }
  295. + #endif
  296. *** 1.36    1992/08/14 17:24:38
  297. --- ld.c    1992/10/11 02:44:29
  298. ***************
  299. *** 396,401 ****
  300. --- 396,406 ----
  301.   #define RELOC_TARGET_BITPOS(r)    0
  302.   #define RELOC_TARGET_BITSIZE(r)    32
  303.   #endif
  304. + #if defined(atarist) || defined(CROSSATARI)
  305. + #define RELOC_ADD_EXTRA(r)    \
  306. +     ((!RELOC_PCREL_P(r) && RELOC_TARGET_SIZE(r) < 2) \
  307. +         ? BASE_OFFSET-text_size : 0)
  308. + #endif
  309.   
  310.   /* Special global symbol types understood by GNU LD.  */
  311.   
  312. ***************
  313. *** 1003,1009 ****
  314.   void copy_text P_((struct file_entry *entry));
  315.   void write_data P_((void));
  316.   void copy_data P_((struct file_entry *entry));
  317. ! void perform_relocation P_((char *data, int pc_relocation, int data_size, struct relocation_info *reloc_info, int reloc_size, struct file_entry *entry));
  318.   void write_rel P_((void));
  319.   void flush_atari_rbuf P_((void));
  320.   int reloc_less_p P_((struct relocation_info *reloc_1, struct relocation_info *reloc_2));
  321. --- 1008,1016 ----
  322.   void copy_text P_((struct file_entry *entry));
  323.   void write_data P_((void));
  324.   void copy_data P_((struct file_entry *entry));
  325. ! void perform_relocation P_((char *data, int pc_relocation, int data_size,
  326. !     struct relocation_info *reloc_info, int reloc_size,
  327. !     struct file_entry *entry, int pure_text));
  328.   void write_rel P_((void));
  329.   void flush_atari_rbuf P_((void));
  330.   int reloc_less_p P_((struct relocation_info *reloc_1, struct relocation_info *reloc_2));
  331. ***************
  332. *** 2715,2725 ****
  333.               if (symdef_base[j].library_member_offset == offset)
  334.                 symdef_base[j].symbol_name_string_index = -1;
  335.                 }
  336.             }
  337. - 
  338. -         /* We'll read the strings again if we need them again.  */
  339. -         free (subentry->strings);
  340. -                 subentry->strings = 0;
  341.             }
  342.         }
  343.       }
  344. --- 2722,2731 ----
  345.               if (symdef_base[j].library_member_offset == offset)
  346.                 symdef_base[j].symbol_name_string_index = -1;
  347.                 }
  348. +             /* We'll read the strings again if we need them again.  */
  349. +             free (subentry->strings);
  350. +             subentry->strings = 0;
  351.             }
  352.             }
  353.         }
  354.       }
  355. ***************
  356. *** 2977,2983 ****
  357.      text segment.  This is right for the type 0x601A Tos header
  358.      and also for the standard Stminix header 
  359.   */ 
  360. !   data_start = text_start + text_size; 
  361.   #else
  362.     if (! Tdata_flag_specified)
  363.       data_start = N_DATADDR (outheader) + text_start - N_TXTADDR (outheader);
  364. --- 2983,2990 ----
  365.      text segment.  This is right for the type 0x601A Tos header
  366.      and also for the standard Stminix header 
  367.   */ 
  368. !   if (! Tdata_flag_specified)
  369. !     data_start = text_start + text_size; 
  370.   #else
  371.     if (! Tdata_flag_specified)
  372.       data_start = N_DATADDR (outheader) + text_start - N_TXTADDR (outheader);
  373. ***************
  374. *** 3954,3959 ****
  375. --- 3961,3968 ----
  376.     /* TOS */
  377.     outheader.a_AZero1 = 0;        /* good a place as any to do this */
  378.     outheader.a_ldflgs = 0;        /* fastload is NOT the default */
  379. +   if (magic == NMAGIC)
  380. +     outheader.a_ldflgs = F_SHTEXT;    /* sharable text */
  381.     outheader.a_isreloc = ISRELOCINFO;    /* means reloc present (!) */
  382.   #endif
  383.   #endif
  384. ***************
  385. *** 4267,4273 ****
  386.     /* Relocate the text according to the text relocation.  */
  387.   
  388.     perform_relocation (bytes, entry->text_start_address, entry->header.a_text,
  389. !               reloc, entry->header.a_trsize, entry);
  390.   
  391.     /* Write the relocated text to the output file.  */
  392.   
  393. --- 4276,4282 ----
  394.     /* Relocate the text according to the text relocation.  */
  395.   
  396.     perform_relocation (bytes, entry->text_start_address, entry->header.a_text,
  397. !               reloc, entry->header.a_trsize, entry, (magic == NMAGIC));
  398.   
  399.     /* Write the relocated text to the output file.  */
  400.   
  401. ***************
  402. *** 4337,4347 ****
  403.       fatal_with_file ("premature eof in data section of ", entry);
  404.   
  405.     perform_relocation (bytes, entry->data_start_address - entry->header.a_text,
  406. !               entry->header.a_data, reloc, entry->header.a_drsize, entry);
  407.   
  408.     mywrite (bytes, 1, entry->header.a_data, outdesc);
  409.   }
  410.   
  411.   /* Relocate ENTRY's text or data section contents.
  412.      DATA is the address of the contents, in core.
  413.      DATA_SIZE is the length of the contents.
  414. --- 4346,4378 ----
  415.       fatal_with_file ("premature eof in data section of ", entry);
  416.   
  417.     perform_relocation (bytes, entry->data_start_address - entry->header.a_text,
  418. !               entry->header.a_data, reloc, entry->header.a_drsize,
  419. !               entry, 0);
  420.   
  421.     mywrite (bytes, 1, entry->header.a_data, outdesc);
  422.   }
  423.   
  424. + static symbol *
  425. + retsym (p, entry)
  426. +      struct relocation_info *p;
  427. +      struct file_entry *entry;
  428. + {
  429. +   register int symindex = RELOC_SYMBOL (p) * sizeof (struct nlist);
  430. +   register symbol *sp = ((symbol *)
  431. +             (((struct nlist *)
  432. +               (((char *)entry->symbols) + symindex))
  433. +              ->n_un.n_name));
  434. + 
  435. +   if (symindex >= entry->header.a_syms)
  436. +     fatal_with_file ("relocation symbolnum out of range in ", entry);
  437. + 
  438. + #ifdef N_INDR
  439. +   /* Resolve indirection */
  440. +   if ((sp->defined & ~N_EXT) == N_INDR)
  441. +     sp = (symbol *) sp->value;
  442. + #endif
  443. +   return sp;
  444. + }
  445.   /* Relocate ENTRY's text or data section contents.
  446.      DATA is the address of the contents, in core.
  447.      DATA_SIZE is the length of the contents.
  448. ***************
  449. *** 4352,4358 ****
  450.   /* This version is about to be severley hacked by Randy.  Hope it
  451.      works afterwards. */
  452.   void
  453. ! perform_relocation (data, pc_relocation, data_size, reloc_info, reloc_size, entry)
  454.        char *data;
  455.        struct relocation_info *reloc_info;
  456.        struct file_entry *entry;
  457. --- 4383,4390 ----
  458.   /* This version is about to be severley hacked by Randy.  Hope it
  459.      works afterwards. */
  460.   void
  461. ! perform_relocation (data, pc_relocation, data_size, reloc_info, reloc_size,
  462. !     entry, pure_text)
  463.        char *data;
  464.        struct relocation_info *reloc_info;
  465.        struct file_entry *entry;
  466. ***************
  467. *** 4359,4364 ****
  468. --- 4391,4397 ----
  469.        int pc_relocation;
  470.        int data_size;
  471.        int reloc_size;
  472. +      int pure_text;
  473.   {
  474.     register struct relocation_info *p = reloc_info;
  475.     struct relocation_info *end
  476. ***************
  477. *** 4373,4378 ****
  478. --- 4406,4412 ----
  479.         register int relocation = 0;
  480.         register int addr;
  481.         register unsigned int mask = 0;
  482. +       symbol *sp;
  483.   
  484.   #ifdef BYTE_SWAP    /* swap relocation info */
  485.   { /* BITFIELD ALERT BITFIELD ALERT */
  486. ***************
  487. *** 4395,4414 ****
  488.   
  489.         if (RELOC_EXTERN_P(p))
  490.       {
  491. !       int symindex = RELOC_SYMBOL (p) * sizeof (struct nlist);
  492. !       symbol *sp = ((symbol *)
  493. !             (((struct nlist *)
  494. !               (((char *)entry->symbols) + symindex))
  495. !              ->n_un.n_name));
  496. ! 
  497. ! #ifdef N_INDR
  498. !       /* Resolve indirection */
  499. !       if ((sp->defined & ~N_EXT) == N_INDR)
  500. !         sp = (symbol *) sp->value;
  501. ! #endif
  502. ! 
  503. !       if (symindex >= entry->header.a_syms)
  504. !         fatal_with_file ("relocation symbolnum out of range in ", entry);
  505.   
  506.         /* If the symbol is undefined, leave it at zero.  */
  507.         if (! sp->defined)
  508. --- 4429,4435 ----
  509.   
  510.         if (RELOC_EXTERN_P(p))
  511.       {
  512. !       sp = retsym(p, entry);
  513.   
  514.         /* If the symbol is undefined, leave it at zero.  */
  515.         if (! sp->defined)
  516. ***************
  517. *** 4475,4482 ****
  518.         break;
  519.   
  520.       case 1:
  521. !       if (RELOC_MEMORY_ADD_P(p))
  522. !         relocation += mask & *(short *) (data + addr);
  523.         *(short *) (data + addr) &= ~mask;
  524.         *(short *) (data + addr) |= relocation;
  525.         break;
  526. --- 4496,4513 ----
  527.         break;
  528.   
  529.       case 1:
  530. !       if (RELOC_MEMORY_ADD_P(p)) {
  531. !         if (RELOC_PCREL_P(p))
  532. !           relocation += mask & *(short *) (data + addr);
  533. !         else
  534. !           relocation += mask & *(unsigned short *) (data + addr);
  535. !       }
  536. !       if (relocation > 32767 || relocation < -32768) {
  537. !         sp = retsym(p, entry);
  538. !         error ("relocation out of range for %s in %s",
  539. !             sp->name, entry->filename);
  540. !         make_executable = 0;
  541. !       }
  542.         *(short *) (data + addr) &= ~mask;
  543.         *(short *) (data + addr) |= relocation;
  544.         break;
  545. ***************
  546. *** 4498,4503 ****
  547. --- 4529,4540 ----
  548.   
  549.         if (RELOC_MEMORY_ADD_P(p))
  550.           relocation += mask & word;
  551. +       if (pure_text && relocation > text_size+text_start) {
  552. +         sp = retsym(p, entry);
  553. +         error ("absolute reference to %s from pure-text in %s",
  554. +         sp->name, entry->filename);
  555. +         make_executable = 0;    /* set exit code */
  556. +       }
  557.         word &= ~mask;
  558.         word |= relocation;
  559.         data[addr] = word >> 24;
  560. ***************
  561. *** 4671,4677 ****
  562.     qsort(entry->textrel, n_relocs, sizeof (struct relocation_info), 
  563.       reloc_less_p);
  564.     for (reloc_num = n_relocs - 1 ; reloc_num >= 0 ; reloc_num-- )
  565. !     if (!emit_atari_reloc(entry->textrel[reloc_num].r_address + text_base))
  566.           fprintf(stderr, "  while processing text rel %d/%d of entry %s\n",
  567.           reloc_num, n_relocs, entry->filename);
  568.   }
  569. --- 4708,4715 ----
  570.     qsort(entry->textrel, n_relocs, sizeof (struct relocation_info), 
  571.       reloc_less_p);
  572.     for (reloc_num = n_relocs - 1 ; reloc_num >= 0 ; reloc_num-- )
  573. !     if ((entry->textrel[reloc_num].r_length == 2) &&
  574. !       !emit_atari_reloc(entry->textrel[reloc_num].r_address + text_base))
  575.           fprintf(stderr, "  while processing text rel %d/%d of entry %s\n",
  576.           reloc_num, n_relocs, entry->filename);
  577.   }
  578. *** 1.21    1992/07/30 20:53:34
  579. --- sym-ld.c    1992/10/11 02:44:31
  580. ***************
  581. *** 892,898 ****
  582. --- 892,902 ----
  583.   
  584.   int xmalloc ();
  585.   int xrealloc ();
  586. + #if __STDC__
  587. + void fatal (char *string, ...);
  588. + #else
  589.   void fatal ();
  590. + #endif
  591.   void fatal_with_file ();
  592.   void perror_name ();
  593.   void perror_file ();
  594. ***************
  595. *** 2435,2445 ****
  596.               if (symdef_base[j].library_member_offset == offset)
  597.                 symdef_base[j].symbol_name_string_index = -1;
  598.                 }
  599.             }
  600. - 
  601. -         /* We'll read the strings again if we need them again.  */
  602. -         free (subentry->strings);
  603. -                 subentry->strings = 0;
  604.             }
  605.         }
  606.       }
  607. --- 2439,2448 ----
  608.               if (symdef_base[j].library_member_offset == offset)
  609.                 symdef_base[j].symbol_name_string_index = -1;
  610.                 }
  611. +             /* We'll read the strings again if we need them again.  */
  612. +             free (subentry->strings);
  613. +             subentry->strings = 0;
  614.             }
  615.             }
  616.         }
  617.       }
  618. ***************
  619. *** 4913,4919 ****
  620.   
  621.   int
  622.   parse (arg, format, error)
  623. !      char *arg, *format;
  624.   {
  625.     int x;
  626.     if (1 != sscanf (arg, format, &x))
  627. --- 4916,4922 ----
  628.   
  629.   int
  630.   parse (arg, format, error)
  631. !      char *arg, *format, *error;
  632.   {
  633.     int x;
  634.     if (1 != sscanf (arg, format, &x))
  635. *** 1.2    1992/07/21 14:52:06
  636. --- toglclr.c    1992/10/11 02:44:31
  637. ***************
  638. *** 1,9 ****
  639. ! /*
  640. !  * utility to toggle clear TPA beyond BSS flag in .prg header for Tos 1.4
  641.    *
  642. !  *    Usage: toglclr file file ....
  643.    *
  644. !  *    ++jrb
  645.    */
  646.   
  647.   #include <stdio.h>
  648. --- 1,26 ----
  649. ! /*                             -*- Mode: Elec-C -*- 
  650. !  * toglclr.c -- utility to toggle the program load flags in the .prg header.
  651.    *
  652. !  *              usage: toglclr [options] file file ...
  653. !  * 
  654. !  * Author          : J.R. Bammi, modified by F. Ridderbusch
  655. !  * Created On      : Some time ago.
  656. !  * Last Modified By: J.R. Bammi
  657. !  * Last Modified On: Fri Sep 25 12:00:28 1992
  658. !  * Update Count    : 6
  659. !  * Status          : Unknown, Use with caution!
  660. !  */
  661. ! 
  662. ! /* HISTORY 
  663. !  * 25-Sep-1992          ++jrb
  664. !  *    Added support for cross-environment with support for 
  665. !  *    WORD_ALIGNED hosts.
  666.    *
  667. !  * 13-Sep-1992        Frank Ridderbusch    
  668. !  *    This program was originally written by J.R. Bammi
  669. !  *    (bammi@cadence.com) to toggle the clear TPA above BSS flag
  670. !  *    introduced with TOS 1.4. I extended it to also handle the additional
  671. !  *    program flags introduced with the TOS versions for the STE and TT.
  672.    */
  673.   
  674.   #include <stdio.h>
  675. ***************
  676. *** 13,21 ****
  677.   #include <st-out.h>
  678.   
  679.   #ifndef FILENAME_MAX
  680. ! #  define FILENAME_MAX 128
  681.   #endif
  682.   
  683.   int toggle (fd, fn)
  684.   int fd;
  685.   char *fn;
  686. --- 30,111 ----
  687.   #include <st-out.h>
  688.   
  689.   #ifndef FILENAME_MAX
  690. ! #define FILENAME_MAX 1024
  691.   #endif
  692.   
  693. + int flags_to_toggle = 0;
  694. + 
  695. + #ifdef WORD_ALIGNED
  696. + 
  697. + #define ckread(addr, bytes, fd) if(read(fd, addr, bytes) != bytes) return 1;
  698. + #define ckwrite(addr, bytes, fd) if(write(fd, addr, bytes) != bytes) return 1;
  699. + 
  700. + int readhead(h, fd)
  701. + struct aexec *h;
  702. + int fd;
  703. + {
  704. +     short i;
  705. +     long j;
  706. +     int k;
  707. +     
  708. +     ckread(&i, 2, fd);
  709. +     h->a_magic = i;
  710. +     ckread(&j, 4, fd);
  711. +     h->a_text = j;
  712. +     ckread(&j, 4, fd);
  713. +     h->a_data = j;
  714. +     ckread(&j, 4, fd);
  715. +     h->a_bss = j;
  716. +     ckread(&j, 4, fd);
  717. +     h->a_syms = j;
  718. +     ckread(&j, 4, fd);
  719. +     h->a_AZero1 = j;
  720. +     ckread(&j, 4, fd);
  721. +     h->a_ldflgs = j;
  722. +     ckread(&i, 2, fd);
  723. +     h->a_isreloc = i;
  724. + 
  725. +     return 0;
  726. + }
  727. + 
  728. + int writehead(h, fd)
  729. + struct aexec *h;
  730. + int fd;
  731. + {
  732. +     short i;
  733. +     long j;
  734. +     int k;
  735. +     
  736. +     i = h->a_magic;
  737. +     ckwrite(&i, 2, fd);
  738. +     j = h->a_text;
  739. +     ckwrite(&j, 4, fd);
  740. +     j = h->a_data;
  741. +     ckwrite(&j, 4, fd);
  742. +     j = h->a_bss;
  743. +     ckwrite(&j, 4, fd);
  744. +     j = h->a_syms;
  745. +     ckwrite(&j, 4, fd);
  746. +     j = h->a_AZero1;
  747. +     ckwrite(&j, 4, fd);
  748. +     j = h->a_ldflgs;
  749. +     ckwrite(&j, 4, fd);
  750. +     i = h->a_isreloc;
  751. +     ckwrite(&i, 2, fd);
  752. + 
  753. +     return 0;
  754. + }
  755. + 
  756. + #else
  757. + 
  758. + #define readhead(addr, fd) \
  759. +  (read(fd, addr, sizeof(struct aexec)) != sizeof(struct aexec))
  760. + 
  761. + #define writehead(addr, fd) \
  762. +  (write(fd, addr, sizeof(struct aexec)) != sizeof(struct aexec))
  763. + 
  764. + #endif /* WORD_ALIGNED */
  765. + 
  766.   int toggle (fd, fn)
  767.   int fd;
  768.   char *fn;
  769. ***************
  770. *** 22,29 ****
  771.   {
  772.       struct aexec head;
  773.       unsigned long t;
  774.       
  775. !     if(read(fd, &head, sizeof(head)) != sizeof(head))
  776.       {
  777.       perror(fn);
  778.       return 4;
  779. --- 112,120 ----
  780.   {
  781.       struct aexec head;
  782.       unsigned long t;
  783. +     char *ptr;
  784.       
  785. !     if(readhead(&head, fd))
  786.       {
  787.       perror(fn);
  788.       return 4;
  789. ***************
  790. *** 35,49 ****
  791.       }
  792.   
  793.       t = head.a_AZero2;
  794. !     head.a_AZero2 ^= 1;
  795. !     lseek(fd, 0L, SEEK_SET);
  796. !     if(write(fd, &head, sizeof(head)) != sizeof(head))
  797.       {
  798. !     perror(fn);
  799. !     return 16;
  800.       }
  801.   
  802. !     printf("%s: was %d is %d\n", fn, (int)t, (int)head.a_AZero2);
  803.       return 0;
  804.   }
  805.   
  806. --- 126,154 ----
  807.       }
  808.   
  809.       t = head.a_AZero2;
  810. !     if (flags_to_toggle)
  811.       {
  812. !         head.a_AZero2 ^= flags_to_toggle;
  813. !         lseek(fd, 0L, SEEK_SET);
  814. !     if(writehead(&head, fd))
  815. !         {
  816. !         perror(fn);
  817. !         return 16;
  818. !         }
  819.       }
  820.   
  821. !     printf("%s:            `fast load' bit was %d is now %d\n", fn, 
  822. !        (int)((t & F_FASTLOAD) == F_FASTLOAD),
  823. !        (int)((head.a_AZero2 & F_FASTLOAD) == F_FASTLOAD));
  824. ! 
  825. !     printf("%s:      `run in fast ram' bit was %d is now %d\n", fn, 
  826. !        (int)((t & F_ALTLOAD) == F_ALTLOAD),
  827. !        (int)((head.a_AZero2 & F_ALTLOAD) == F_ALTLOAD));
  828. ! 
  829. !     printf("%s: `malloc from fast ram' bit was %d is now %d\n", fn, 
  830. !        (int)((t & F_ALTALLOC) == F_ALTALLOC),
  831. !        (int)((head.a_AZero2 & F_ALTALLOC) == F_ALTALLOC));
  832. ! 
  833.       return 0;
  834.   }
  835.   
  836. ***************
  837. *** 57,69 ****
  838.       
  839.       if(argc < 2)
  840.       {
  841. !     fprintf(stderr, "usage: toglclr file file .....\n");
  842.       exit(1);
  843.       }
  844.   
  845.       while(--argc > 0)
  846.       {
  847. !     (void) strcpy(fn, *++argv);
  848.           if((fd = open(fn, 2)) < 0)
  849.           {
  850.           perror(fn);
  851. --- 162,189 ----
  852.       
  853.       if(argc < 2)
  854.       {
  855. !     fprintf(stderr, "usage: toglclr [options] file file .....\n\n");
  856. !     fprintf(stderr, "options: -fload = toggle `fast load' bit\n");
  857. !     fprintf(stderr, "         -frun  = toggle `load program into fast ram' bit\n");
  858. !     fprintf(stderr, "         -fram  = toggle `malloc from fast ram' bit\n\n");
  859. !     fprintf(stderr, "without options the current state is reported.\n");
  860.       exit(1);
  861.       }
  862.   
  863. +     while (**++argv == '-')
  864. +     {
  865. +         if (!strcmp(*argv, "-fload"))
  866. +         flags_to_toggle |= F_FASTLOAD;
  867. +         if (!strcmp(*argv, "-frun"))
  868. +         flags_to_toggle |= F_ALTLOAD;
  869. +         if (!strcmp(*argv, "-fram"))
  870. +         flags_to_toggle |= F_ALTALLOC;
  871. +     --argc;
  872. +     }
  873. + 
  874.       while(--argc > 0)
  875.       {
  876. !     (void) strcpy(fn, *argv++);
  877.           if((fd = open(fn, 2)) < 0)
  878.           {
  879.           perror(fn);
  880. ***************
  881. *** 79,82 ****
  882.       
  883.       return status;
  884.   }
  885. - 
  886. --- 199,201 ----
  887.